home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Rozne / HTTrack 3.40-2 / httrack-3.40-2.exe / {app} / src / proxy / store.c < prev    next >
C/C++ Source or Header  |  2006-04-09  |  45KB  |  1,506 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20. Please visit our Website: http://www.httrack.com
  21. */
  22.  
  23. /* ------------------------------------------------------------ */
  24. /* File: Cache manager for ProxyTrack                           */
  25. /* Author: Xavier Roche                                         */
  26. /* ------------------------------------------------------------ */
  27.  
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31.  
  32. /* Locking */
  33. #ifdef _WIN32
  34. #include <process.h>    /* _beginthread, _endthread */
  35. #else
  36. #include <pthread.h>
  37. #endif
  38.  
  39. #include "htsglobal.h"
  40.  
  41. #define HTS_INTERNAL_BYTECODE
  42. #include "htsinthash.h"
  43. #undef HTS_INTERNAL_BYTECODE
  44. #include "../minizip/mztools.h"
  45.  
  46. #include "htscore.h"
  47. #include "htsback.h"
  48.  
  49. #include "store.h"
  50. #include "proxystrings.h"
  51. #include "proxytrack.h"
  52.  
  53. /* Unlocked functions */
  54.  
  55. static int PT_LookupCache__New_u(PT_Index index, const char* url);
  56. static PT_Element PT_ReadCache__New_u(PT_Index index, const char* url, int flags);
  57.  
  58. static int PT_LookupCache__Old_u(PT_Index index, const char* url);
  59. static PT_Element PT_ReadCache__Old_u(PT_Index index, const char* url, int flags);
  60.  
  61.  
  62. /* Locking */
  63.  
  64. #ifdef _WIN32
  65. void MutexInit(PT_Mutex *pMutex) {
  66.     *pMutex = CreateMutex(NULL,FALSE,NULL);
  67. }
  68.  
  69. void MutexLock(PT_Mutex *pMutex) {
  70.     WaitForSingleObject(*pMutex, INFINITE);
  71. }
  72.  
  73. void MutexUnlock(PT_Mutex *pMutex) {
  74.     ReleaseMutex(*pMutex);
  75. }
  76.  
  77. void MutexFree(PT_Mutex *pMutex) {
  78.     CloseHandle(*pMutex);
  79.     *pMutex = NULL;
  80. }
  81. #else
  82. void MutexInit(PT_Mutex *pMutex) {
  83.     (void) pthread_mutex_init(pMutex, 0);
  84. }
  85.  
  86. void MutexLock(PT_Mutex *pMutex) {
  87.     pthread_mutex_lock(pMutex);
  88. }
  89.  
  90. void MutexUnlock(PT_Mutex *pMutex) {
  91.     pthread_mutex_unlock(pMutex);
  92. }
  93.  
  94. void MutexFree(PT_Mutex *pMutex) {
  95.     pthread_mutex_destroy(pMutex);
  96. }
  97. #endif
  98.  
  99. /* Indexes */
  100.  
  101. typedef struct _PT_Index__New _PT_Index__New;
  102. typedef struct _PT_Index__Old _PT_Index__Old;
  103. typedef struct _PT_Index_Functions _PT_Index_Functions;
  104.  
  105. typedef struct _PT_Index__New *PT_Index__New;
  106. typedef struct _PT_Index__Old *PT_Index__Old;
  107. typedef struct _PT_Index_Functions *PT_Index_Functions;
  108.  
  109. enum {
  110.     PT_CACHE_UNDEFINED = -1,
  111.     PT_CACHE_MIN = 0,
  112.     PT_CACHE__NEW = PT_CACHE_MIN,
  113.     PT_CACHE__OLD,
  114.     PT_CACHE_MAX = PT_CACHE__OLD
  115. };
  116.  
  117. static int PT_LoadCache__New(PT_Index index, const char *filename);
  118. static void PT_Index_Delete__New(PT_Index *pindex);
  119. static PT_Element PT_ReadCache__New(PT_Index index, const char* url, int flags);
  120. static int PT_LookupCache__New(PT_Index index, const char* url);
  121. /**/
  122. static int PT_LoadCache__Old(PT_Index index, const char *filename);
  123. static void PT_Index_Delete__Old(PT_Index *pindex);
  124. static PT_Element PT_ReadCache__Old(PT_Index index, const char* url, int flags);
  125. static int PT_LookupCache__Old(PT_Index index, const char* url);
  126.  
  127. struct _PT_Index_Functions {
  128.     int (*PT_LoadCache)(PT_Index index, const char *filename);
  129.     void (*PT_Index_Delete)(PT_Index *pindex);
  130.     PT_Element (*PT_ReadCache)(PT_Index index, const char* url, int flags);
  131.     int (*PT_LookupCache)(PT_Index index, const char* url);
  132. };
  133.  
  134. static _PT_Index_Functions _IndexFuncts[] = {
  135.   { PT_LoadCache__New, PT_Index_Delete__New, PT_ReadCache__New, PT_LookupCache__New },
  136.   { PT_LoadCache__Old, PT_Index_Delete__Old, PT_ReadCache__Old, PT_LookupCache__Old },
  137.     { NULL, NULL, NULL, NULL }
  138. };
  139.  
  140. #define PT_INDEX_COMMON_STRUCTURE \
  141.     time_t timestamp;                                \
  142.     inthash hash;                                        \
  143.     char startUrl[1024]
  144.  
  145. struct _PT_Index__New {
  146.     PT_INDEX_COMMON_STRUCTURE;
  147.     char path[1024];        /* either empty, or must include ending / */
  148.     int fixedPath;
  149.     int safeCache;
  150.     unzFile zFile;
  151.     PT_Mutex zFileLock;
  152. };
  153.  
  154. struct _PT_Index__Old {
  155.     PT_INDEX_COMMON_STRUCTURE;
  156.     char filenameDat[1024];
  157.     char filenameNdx[1024];
  158.     FILE *dat,*ndx;
  159.     PT_Mutex fileLock;
  160.     int version;
  161.     char lastmodified[1024];
  162.     char path[1024];        /* either empty, or must include ending / */
  163.     int fixedPath;
  164.     int safeCache;
  165. };
  166.  
  167. struct _PT_Index {
  168.     int type;
  169.     union {
  170.         _PT_Index__New formatNew;
  171.         _PT_Index__Old formatOld;
  172.         struct {
  173.             PT_INDEX_COMMON_STRUCTURE;
  174.         } common;
  175.     } slots;
  176. };
  177.  
  178. struct _PT_Indexes {
  179.     inthash cil;
  180.     struct _PT_Index **index;
  181.     int index_size;
  182. };
  183.  
  184. struct _PT_CacheItem {
  185.     time_t lastUsed;
  186.     size_t size;
  187.     void* data;
  188. };
  189.  
  190. struct _PT_Cache {
  191.     inthash index;
  192.     size_t maxSize;
  193.     size_t totalSize;
  194.     int count;
  195. };
  196.  
  197. PT_Indexes PT_New() {
  198.     PT_Indexes index = (PT_Indexes) calloc(sizeof(_PT_Indexes), 1);
  199.     index->cil = inthash_new(127);
  200.     index->index_size = 0;
  201.     index->index = NULL;
  202.     return index;
  203. }
  204.  
  205. void PT_Delete(PT_Indexes index) {
  206.     if (index != NULL) {
  207.         inthash_delete(&index->cil);
  208.         free(index);
  209.     }
  210. }
  211.  
  212. int PT_RemoveIndex(PT_Indexes index, int indexId) {
  213.     return 0;
  214. }
  215.  
  216. #define assertf(exp)
  217.  
  218. static int binput(char* buff,char* s,int max) {
  219.   int count = 0;
  220.   int destCount = 0;
  221.  
  222.   // Note: \0 will return 1
  223.   while(destCount < max && buff[count] != '\0' && buff[count] != '\n') {
  224.     if (buff[count] != '\r') {
  225.       s[destCount++] = buff[count];
  226.     }
  227.         count++;
  228.   }
  229.   s[destCount] = '\0';
  230.  
  231.   // then return the supplemental jump offset
  232.   return count + 1;
  233. }
  234.  
  235. static time_t file_timestamp(const char* file) {
  236.   struct stat buf;
  237.   if (stat(file, &buf) == 0) {
  238.     time_t tt = buf.st_mtime;
  239.         if (tt != (time_t) 0 && tt != (time_t) -1) {
  240.             return tt;
  241.         }
  242.   }
  243.   return (time_t) 0;
  244. }
  245.  
  246. static int PT_Index_Check__(PT_Index index, const char* file, int line) {
  247.     if (index == NULL)
  248.         return 0;
  249.     if (index->type >= PT_CACHE_MIN && index->type <= PT_CACHE_MAX)
  250.         return 1;
  251.     CRITICAL_("index corrupted in memory", file, line);
  252.     return 0;
  253. }
  254. #define SAFE_INDEX(index) PT_Index_Check__(index, __FILE__, __LINE__)
  255.  
  256.  
  257. /* ------------------------------------------------------------ */
  258. /* Generic cache dispatch                                       */
  259. /* ------------------------------------------------------------ */
  260.  
  261. void PT_Index_Delete(PT_Index *pindex) {
  262.     if (pindex != NULL && (*pindex) != NULL) {
  263.         PT_Index index = *pindex;
  264.         if (SAFE_INDEX(index)) {
  265.             _IndexFuncts[index->type].PT_Index_Delete(pindex);
  266.         }
  267.         free(index);
  268.         *pindex = NULL;
  269.     }
  270. }
  271.  
  272. static void PT_Index_Delete__New(PT_Index *pindex) {
  273.     if (pindex != NULL && (*pindex) != NULL) {
  274.         PT_Index__New index = &(*pindex)->slots.formatNew;
  275.         if (index->zFile != NULL) {
  276.             unzClose(index->zFile);
  277.             index->zFile = NULL;
  278.         }
  279.         if (index->hash != NULL) {
  280.             inthash_delete(&index->hash);
  281.             index->hash = NULL;
  282.         }
  283.         MutexFree(&index->zFileLock);
  284.     }
  285. }
  286.  
  287. static void PT_Index_Delete__Old(PT_Index *pindex) {
  288.     if (pindex != NULL && (*pindex) != NULL) {
  289.         PT_Index__Old index = &(*pindex)->slots.formatOld;
  290.         if (index->dat != NULL) {
  291.             fclose(index->dat);
  292.         }
  293.         if (index->ndx != NULL) {
  294.             fclose(index->ndx);
  295.         }
  296.         if (index->hash != NULL) {
  297.             inthash_delete(&index->hash);
  298.             index->hash = NULL;
  299.         }
  300.         MutexFree(&index->fileLock);
  301.     }
  302. }
  303.  
  304. int PT_AddIndex(PT_Indexes indexes, const char *path) {
  305.     PT_Index index = PT_LoadCache(path);
  306.     if (index != NULL) {
  307.         int ret = PT_IndexMerge(indexes, &index);
  308.         if (index != NULL) {
  309.             PT_Index_Delete(&index);
  310.         }
  311.         return ret;
  312.     }
  313.     return -1;
  314. }
  315.  
  316. PT_Element PT_Index_HTML_BuildRootInfo(PT_Indexes indexes) {
  317.     if (indexes != NULL) {
  318.         PT_Element elt = PT_ElementNew();
  319.         int i;
  320.         String html = STRING_EMPTY;
  321.         StringClear(html);
  322.         StringStrcat(html, 
  323.             "<html>"
  324.             PROXYTRACK_COMMENT_HEADER
  325.             DISABLE_IE_FRIENDLY_HTTP_ERROR_MESSAGES
  326.             "<head>\r\n"
  327.             "<title>ProxyTrack " PROXYTRACK_VERSION " Catalog</title>"
  328.             "</head>\r\n"
  329.             "<body>\r\n"
  330.             "<h3>Available sites in this cache:</h3><br />"
  331.             "<br />"
  332.             );
  333.         StringStrcat(html, "<ul>\r\n");
  334.         for(i = 0 ; i < indexes->index_size ; i++) {
  335.             if (indexes->index[i] != NULL
  336.                 && indexes->index[i]->slots.common.startUrl[0] != '\0')
  337.             {
  338.                 const char * url = indexes->index[i]->slots.common.startUrl;
  339.                 StringStrcat(html, "<li>\r\n");
  340.                 StringStrcat(html, "<a href=\"");
  341.                 StringStrcat(html, url);
  342.                 StringStrcat(html, "\">");
  343.                 StringStrcat(html, url);
  344.                 StringStrcat(html, "</a>\r\n");
  345.                 StringStrcat(html, "</li>\r\n");
  346.             }
  347.         }
  348.         StringStrcat(html, "</ul>\r\n");
  349.         StringStrcat(html, "</body></html>\r\n");
  350.         elt->size = StringLength(html);
  351.         elt->adr = StringAcquire(&html);
  352.         elt->statuscode = 200;
  353.         strcpy(elt->charset, "iso-8859-1");
  354.         strcpy(elt->contenttype, "text/html");
  355.         strcpy(elt->msg, "OK");
  356.         StringFree(html);
  357.         return elt;
  358.     }
  359.     return NULL;
  360. }
  361.  
  362. static char* strchr_stop(char* str, char c, char stop) {
  363.     for( ; *str != 0 && *str != stop && *str != c ; str++);
  364.     if (*str == c)
  365.         return str;
  366.     return NULL;
  367. }
  368.  
  369. char ** PT_Enumerate(PT_Indexes indexes, const char *url, int subtree) {
  370.     // should be cached!
  371.     if (indexes != NULL && indexes->cil != NULL) {
  372.         unsigned int urlSize;
  373.         String list = STRING_EMPTY;
  374.         String listindexes = STRING_EMPTY;
  375.         String subitem = STRING_EMPTY;
  376.         unsigned int listCount = 0;
  377.         struct_inthash_enum en = inthash_enum_new(indexes->cil);
  378.         inthash_chain* chain;
  379.         inthash hdupes = NULL;
  380.         if (!subtree)
  381.             hdupes= inthash_new(127);
  382.         StringClear(list);
  383.         StringClear(listindexes);
  384.         StringClear(subitem);
  385.         if (strncmp(url, "http://", 7) == 0)
  386.             url += 7;
  387.         urlSize = (unsigned int) strlen(url);
  388.         while((chain = inthash_enum_next(&en))) {
  389.             long int index = (long int)chain->value.intg;
  390.             if (urlSize == 0 || strncmp(chain->name, url, urlSize) == 0) {
  391.                 if (index >= 0 && index < indexes->index_size) {
  392.                     char * item = chain->name + urlSize;
  393.                     if (*item == '/')
  394.                         item++;
  395.                     {
  396.                         char * pos = subtree ? 0 : strchr_stop(item, '/', '?');
  397.                         unsigned int len = pos ? (unsigned int)( pos - item ) : (unsigned int)strlen(item);
  398.                         if (len > 0 /* default document */ || *item == 0) {
  399.                             int isFolder = ( item[len] == '/' );
  400.                             StringClear(subitem);
  401.                             if (len > 0)
  402.                                 StringMemcat(subitem, item, len);
  403.                             if (len == 0 || !inthash_exists(hdupes, StringBuff(subitem))) {
  404.                                 char* ptr = NULL;
  405.                                 ptr += StringLength(list);
  406.                                 if (len > 0)
  407.                                     StringStrcat(list, StringBuff(subitem));
  408.                                 if (isFolder)
  409.                                     StringStrcat(list, "/");
  410.                                 StringMemcat(list, "\0", 1);        /* NULL terminated strings */
  411.                                 StringMemcat(listindexes, &ptr, sizeof(ptr));
  412.                                 listCount++;
  413.                                 inthash_write(hdupes, StringBuff(subitem), 0);
  414.                             }
  415.                         }
  416.                     }
  417.                 } else {
  418.                     CRITICAL("PT_Enumerate:Corrupted central index locator");
  419.                 }
  420.             }
  421.         }
  422.         StringFree(subitem);
  423.         inthash_delete(&hdupes);
  424.         if (listCount > 0) {
  425.             unsigned int i;
  426.             void* blk;
  427.             char *nullPointer = NULL;
  428.             char* startStrings;
  429.             /* NULL terminated index */
  430.             StringMemcat(listindexes, &nullPointer, sizeof(nullPointer));
  431.             /* start of all strings (index) */
  432.             startStrings = nullPointer + StringLength(listindexes);
  433.             /* copy list of URLs after indexes */
  434.             StringMemcat(listindexes, StringBuff(list), StringLength(list));
  435.             /* ---- no reallocation beyond this point (fixed addresses) ---- */
  436.             /* start of all strings (pointer) */
  437.             startStrings = (startStrings - nullPointer) + StringBuff(listindexes);
  438.             /* transform indexes into references */
  439.             for(i = 0 ; i < listCount ; i++) {
  440.                 char *ptr = NULL;
  441.                 unsigned int ndx;
  442.                 memcpy(&ptr, &StringBuff(listindexes)[i*sizeof(char*)], sizeof(char*));
  443.                 ndx = (unsigned int) (ptr - nullPointer);
  444.                 ptr = startStrings + ndx;
  445.                 memcpy(&StringBuff(listindexes)[i*sizeof(char*)], &ptr, sizeof(char*));
  446.             }
  447.             blk = StringAcquire(&listindexes);
  448.             StringFree(list);
  449.             StringFree(listindexes);
  450.             return (char **)blk;
  451.         }
  452.     }
  453.     return NULL;
  454. }
  455.  
  456. void PT_Enumerate_Delete(char ***plist) {
  457.     if (plist != NULL && *plist != NULL) {
  458.         free(*plist);
  459.         *plist = NULL;
  460.     }
  461. }
  462.  
  463. PT_Index PT_LoadCache(const char *filename) {
  464.     int type = PT_CACHE_UNDEFINED;
  465.     char * dot = strrchr(filename, '.');
  466.     if (dot != NULL) {
  467.         if (strcasecmp(dot, ".zip") == 0) {
  468.             type = PT_CACHE__NEW;
  469.         } else if (strcasecmp(dot, ".ndx") == 0 || strcasecmp(dot, ".dat") == 0) {
  470.             type = PT_CACHE__OLD;
  471.         }
  472.     }
  473.     if (type != PT_CACHE_UNDEFINED) {
  474.         PT_Index index = calloc(sizeof(_PT_Index), 1);
  475.         if (index != NULL) {
  476.             index->type = type;
  477.             index->slots.common.timestamp = (time_t) time(NULL);
  478.             index->slots.common.startUrl[0] = '\0';
  479.             index->slots.common.hash = inthash_new(8191);
  480.             if (!_IndexFuncts[type].PT_LoadCache(index, filename)) {
  481.                 DEBUG("reading httrack cache (format #%d) %s : error" _ type _ filename );
  482.                 free(index);
  483.                 index = NULL;
  484.                 return NULL;
  485.             } else {
  486.                 DEBUG("reading httrack cache (format #%d) %s : success" _ type _ filename );
  487.             }
  488.             /* default starting URL is the first hash entry */
  489.             if (index->slots.common.startUrl[0] == '\0') {
  490.                 struct_inthash_enum en = inthash_enum_new(index->slots.common.hash);
  491.                 inthash_chain* chain;
  492.                 chain = inthash_enum_next(&en);
  493.                 if (chain != NULL
  494.                     && strstr(chain->name, "/robots.txt") != NULL) 
  495.                 {
  496.                     chain = inthash_enum_next(&en);
  497.                 }
  498.                 if (chain != NULL) {
  499.                     if (!link_has_authority(chain->name))
  500.                         strcat(index->slots.common.startUrl, "http://");
  501.                     strcat(index->slots.common.startUrl, chain->name);
  502.                 }
  503.             }
  504.         }
  505.         return index;
  506.     }
  507.     return NULL;
  508. }
  509.  
  510.  
  511. static long int filesize(const char* filename) {
  512.   struct stat st;
  513.   memset(&st, 0, sizeof(st));
  514.   if (stat(filename, &st) == 0) {
  515.         return (long int)st.st_size;
  516.   }
  517.   return -1;
  518. } 
  519.  
  520. int PT_LookupCache(PT_Index index, const char* url) {
  521.     if (index != NULL && SAFE_INDEX(index)) {
  522.         return _IndexFuncts[index->type].PT_LookupCache(index, url);
  523.     }
  524.     return 0;
  525. }
  526.  
  527. time_t PT_Index_Timestamp(PT_Index index) {
  528.     return index->slots.common.timestamp;
  529. }
  530.  
  531. static int PT_LookupCache__New(PT_Index index, const char* url) {
  532.     int retCode;
  533.     MutexLock(&index->slots.formatNew.zFileLock);
  534.     {
  535.         retCode = PT_LookupCache__New_u(index, url);
  536.     }
  537.     MutexUnlock(&index->slots.formatNew.zFileLock);
  538.     return retCode;
  539. }
  540.  
  541. static int PT_LookupCache__New_u(PT_Index index_, const char* url) {
  542.     if (index_ != NULL) {
  543.         PT_Index__New index = &index_->slots.formatNew;
  544.         if (index->hash != NULL && index->zFile != NULL && url != NULL && *url != 0) {
  545.             int hash_pos_return;
  546.             if (strncmp(url, "http://", 7) == 0)
  547.                 url += 7;
  548.             hash_pos_return = inthash_read(index->hash, url, NULL);
  549.             if (hash_pos_return)
  550.                 return 1;
  551.         }
  552.     }
  553.     return 0;
  554. }
  555.  
  556. int PT_IndexMerge(PT_Indexes indexes, PT_Index *pindex)
  557. {
  558.     if (pindex != NULL && *pindex != NULL && (*pindex)->slots.common.hash != NULL
  559.         && indexes != NULL) 
  560.     {
  561.         PT_Index index = *pindex;
  562.         struct_inthash_enum en = inthash_enum_new(index->slots.common.hash);
  563.         inthash_chain* chain;
  564.         int index_id = indexes->index_size++;
  565.         int nMerged = 0;
  566.         if ((indexes->index = realloc(indexes->index, sizeof(struct _PT_Index)*indexes->index_size)) != NULL) {
  567.             indexes->index[index_id] = index;
  568.             *pindex = NULL;
  569.             while((chain = inthash_enum_next(&en)) != NULL) {
  570.                 const char * url = chain->name;
  571.                 if (url != NULL && url[0] != '\0') {
  572.                     long int previous_index_id = 0;
  573.                     if (inthash_read(indexes->cil, url, (long int*)&previous_index_id)) {
  574.                         if (previous_index_id >= 0 && previous_index_id < indexes->index_size) {
  575.                             if (indexes->index[previous_index_id]->slots.common.timestamp > index->slots.common.timestamp)            // existing entry is newer
  576.                                 break;
  577.                         } else {
  578.                             CRITICAL("PT_IndexMerge:Corrupted central index locator");
  579.                         }
  580.                     }
  581.                     inthash_write(indexes->cil, chain->name, index_id);
  582.                     nMerged++;
  583.                 }
  584.             }
  585.         } else {
  586.             CRITICAL("PT_IndexMerge:Memory exhausted");
  587.         }
  588.         return nMerged;
  589.     }
  590.     return -1;
  591. }
  592.  
  593. void PT_Element_Delete(PT_Element *pentry) {
  594.     if (pentry != NULL) {
  595.         PT_Element entry = *pentry;
  596.         if (entry != NULL) {
  597.             if (entry->adr != NULL) {
  598.                 free(entry->adr);
  599.                 entry->adr = NULL;
  600.             }
  601.             if (entry->headers != NULL) {
  602.                 free(entry->headers);
  603.                 entry->headers = NULL;
  604.             }
  605.             if (entry->location != NULL) {
  606.                 free(entry->location);
  607.                 entry->location = NULL;
  608.             }
  609.             free(entry);
  610.         }
  611.         *pentry = NULL;
  612.     }
  613. }
  614.  
  615. PT_Element PT_ReadIndex(PT_Indexes indexes, const char* url, int flags)
  616. {
  617.     if (indexes != NULL) 
  618.     {
  619.         long int index_id;
  620.         if (strncmp(url, "http://", 7) == 0)
  621.             url += 7;
  622.         if (inthash_read(indexes->cil, url, &index_id)) {
  623.             if (index_id >= 0 && index_id <= indexes->index_size) {
  624.                 PT_Element item =  PT_ReadCache(indexes->index[index_id], url, flags);
  625.                 if (item != NULL) {
  626.                     item->indexId = index_id;
  627.                     return item;
  628.                 }
  629.             } else {
  630.                 CRITICAL("PT_ReadCache:Corrupted central index locator");
  631.             }
  632.         }
  633.     }
  634.     return NULL;
  635. }
  636.  
  637. int PT_LookupIndex(PT_Indexes indexes, const char* url) {
  638.     if (indexes != NULL) 
  639.     {
  640.         long int index_id;
  641.         if (strncmp(url, "http://", 7) == 0)
  642.             url += 7;
  643.         if (inthash_read(indexes->cil, url, &index_id)) {
  644.             if (index_id >= 0 && index_id <= indexes->index_size) {
  645.                 return 1;
  646.             } else {
  647.                 CRITICAL("PT_ReadCache:Corrupted central index locator");
  648.             }
  649.         }
  650.     }
  651.     return 0;
  652. }
  653.  
  654. PT_Index PT_GetIndex(PT_Indexes indexes, int indexId) {
  655.     if (indexes != NULL && indexId >= 0 && indexId < indexes->index_size) 
  656.     {
  657.         return indexes->index[indexId];
  658.     }
  659.     return NULL;
  660. }
  661.  
  662. PT_Element PT_ElementNew() {
  663.     PT_Element r = NULL;
  664.     if ((r = calloc(sizeof(_PT_Element), 1)) == NULL)
  665.         return NULL;
  666.     r->statuscode=STATUSCODE_INVALID;
  667.     r->indexId = -1;
  668.     return r;
  669. }
  670.  
  671. PT_Element PT_ReadCache(PT_Index index, const char* url, int flags) {
  672.     if (index != NULL && SAFE_INDEX(index)) {
  673.         return _IndexFuncts[index->type].PT_ReadCache(index, url, flags);
  674.     }
  675.     return NULL;
  676. }
  677.  
  678. static PT_Element PT_ReadCache__New(PT_Index index, const char* url, int flags) {
  679.     PT_Element retCode;
  680.     MutexLock(&index->slots.formatNew.zFileLock);
  681.     {
  682.         retCode = PT_ReadCache__New_u(index, url, flags);
  683.     }
  684.     MutexUnlock(&index->slots.formatNew.zFileLock);
  685.     return retCode;
  686. }
  687.  
  688.  
  689. /* ------------------------------------------------------------ */
  690. /* New HTTrack cache (new.zip) format                           */
  691. /* ------------------------------------------------------------ */
  692.  
  693. #define ZIP_READFIELD_STRING(line, value, refline, refvalue) do { \
  694.   if (line[0] != '\0' && strfield2(line, refline)) { \
  695.     strcpy(refvalue, value); \
  696.     line[0] = '\0'; \
  697.     } \
  698. } while(0)
  699. #define ZIP_READFIELD_INT(line, value, refline, refvalue) do { \
  700.   if (line[0] != '\0' && strfield2(line, refline)) { \
  701.     int intval = 0; \
  702.     sscanf(value, "%d", &intval); \
  703.     (refvalue) = intval; \
  704.     line[0] = '\0'; \
  705.     } \
  706. } while(0)
  707.  
  708. int PT_LoadCache__New(PT_Index index_, const char *filename) {
  709.     if (index_ != NULL && filename != NULL) {
  710.         PT_Index__New index = &index_->slots.formatNew;
  711.         unzFile zFile = index->zFile = unzOpen(filename);
  712.         index->timestamp = file_timestamp(filename);
  713.         MutexInit(&index->zFileLock);
  714.  
  715.         // Opened ?
  716.         if (zFile!=NULL) {
  717.             const char * abpath;
  718.             int slashes;
  719.             inthash hashtable = index->hash;
  720.  
  721.             /* Compute base path for this index - the filename MUST be absolute! */
  722.             for(slashes = 2, abpath = filename + (int)strlen(filename) - 1 
  723.                 ; abpath > filename && ( ( *abpath != '/'&& *abpath != '\\' ) || --slashes > 0)
  724.                 ; abpath--);
  725.             index->path[0] = '\0';
  726.             if (slashes == 0 && *abpath != 0) {
  727.                 int i;
  728.                 strncat(index->path, filename, (int) ( abpath - filename ) + 1 );
  729.                 for(i = 0 ; index->path[i] != 0 ; i++) {
  730.                     if (index->path[i] == '\\') {
  731.                         index->path[i] = '/';
  732.                     }
  733.                 }
  734.             }
  735.  
  736.             /* Ready directory entries */
  737.             if (unzGoToFirstFile(zFile) == Z_OK) {
  738.                 char comment[128];
  739.                 char filename[HTS_URLMAXSIZE * 4];
  740.                 int entries = 0;
  741.                 int firstSeen = 0;
  742.                 memset(comment, 0, sizeof(comment));       // for truncated reads
  743.                 do  {
  744.                     int readSizeHeader = 0;
  745.                     filename[0] = '\0';
  746.                     comment[0] = '\0';
  747.                     if (unzOpenCurrentFile(zFile) == Z_OK) {
  748.                         if (
  749.                             (readSizeHeader = unzGetLocalExtrafield(zFile, comment, sizeof(comment) - 2)) > 0
  750.                             &&
  751.                             unzGetCurrentFileInfo(zFile, NULL, filename, sizeof(filename) - 2, NULL, 0, NULL, 0) == Z_OK
  752.                             ) 
  753.                         {
  754.                             long int pos = (long int) unzGetOffset(zFile);
  755.                             assertf(readSizeHeader < sizeof(comment));
  756.                             comment[readSizeHeader] = '\0';
  757.                             entries++;
  758.                             if (pos > 0) {
  759.                                 int dataincache = 0;    // data in cache ?
  760.                                 char* filenameIndex = filename;
  761.                                 if (strncmp(filenameIndex, "http://", 7) == 0) {
  762.                                     filenameIndex += 7;
  763.                                 }
  764.                                 if (comment[0] != '\0') {
  765.                                     int maxLine = 2;
  766.                                     char* a = comment;
  767.                                     while(*a && maxLine-- > 0) {      // parse only few first lines
  768.                                         char line[1024];
  769.                                         line[0] = '\0';
  770.                                         a+=binput(a, line, sizeof(line) - 2);
  771.                                         if (strncmp(line, "X-In-Cache:", 11) == 0) {
  772.                                             if (strcmp(line, "X-In-Cache: 1") == 0) {
  773.                                                 dataincache = 1;
  774.                                             } else {
  775.                                                 dataincache = 0;
  776.                                             }
  777.                                             break;
  778.                                         }
  779.                                     }
  780.                                 }
  781.                                 if (dataincache)
  782.                                     inthash_add(hashtable, filenameIndex, pos);
  783.                                 else
  784.                                     inthash_add(hashtable, filenameIndex, -pos);
  785.  
  786.                                 /* First link as starting URL */
  787.                                 if (!firstSeen) {
  788.                                     if (strstr(filenameIndex, "/robots.txt") == NULL) {
  789.                                         firstSeen = 1;
  790.                                         if (!link_has_authority(filenameIndex))
  791.                                             strcat(index->startUrl, "http://");
  792.                                         strcat(index->startUrl, filenameIndex);
  793.                                     }
  794.                                 }
  795.                             } else {
  796.                                 fprintf(stderr, "Corrupted cache meta entry #%d"LF, (int)entries);
  797.                             }
  798.                         } else {
  799.                             fprintf(stderr, "Corrupted cache entry #%d"LF, (int)entries);
  800.                         }
  801.                         unzCloseCurrentFile(zFile);
  802.                     } else {
  803.                         fprintf(stderr, "Corrupted cache entry #%d"LF, (int)entries);
  804.                     }
  805.                 } while( unzGoToNextFile(zFile) == Z_OK );
  806.                 return 1;
  807.             } else {
  808.                 inthash_delete(&index->hash);
  809.                 index = NULL;
  810.             }
  811.         } else {
  812.             index = NULL;
  813.         }
  814.     }
  815.     return 0;
  816. }
  817.  
  818. static PT_Element PT_ReadCache__New_u(PT_Index index_, const char* url, int flags)
  819. {
  820.     PT_Index__New index = (PT_Index__New) &index_->slots.formatNew;
  821.   char location_default[HTS_URLMAXSIZE*2];
  822.   char previous_save[HTS_URLMAXSIZE*2];
  823.   char previous_save_[HTS_URLMAXSIZE*2];
  824.   long int hash_pos;
  825.   int hash_pos_return;
  826.     PT_Element r = NULL;
  827.     if (index == NULL || index->hash == NULL || index->zFile == NULL || url == NULL || *url == 0)
  828.         return NULL;
  829.     if ((r = PT_ElementNew()) == NULL)
  830.         return NULL;
  831.     location_default[0] = '\0';
  832.     previous_save[0] = previous_save_[0] = '\0';
  833.   memset(r, 0, sizeof(_PT_Element));
  834.   r->location = location_default;
  835.     strcpy(r->location, ""); 
  836.     if (strncmp(url, "http://", 7) == 0)
  837.         url += 7;
  838.   hash_pos_return = inthash_read(index->hash, url, (long int*)&hash_pos);
  839.  
  840.   if (hash_pos_return) {
  841.     uLong posInZip;
  842.     if (hash_pos > 0) {
  843.       posInZip = (uLong) hash_pos;
  844.     } else {
  845.       posInZip = (uLong) -hash_pos;
  846.     }
  847.         if (unzSetOffset(index->zFile, posInZip) == Z_OK) {
  848.       /* Read header (Max 8KiB) */
  849.       if (unzOpenCurrentFile(index->zFile) == Z_OK) {
  850.         char headerBuff[8192 + 2];
  851.         int readSizeHeader;
  852.         int totalHeader = 0;
  853.         int dataincache = 0;
  854.         
  855.         /* For BIG comments */
  856.         headerBuff[0] 
  857.           = headerBuff[sizeof(headerBuff) - 1] 
  858.           = headerBuff[sizeof(headerBuff) - 2] 
  859.           = headerBuff[sizeof(headerBuff) - 3] = '\0';
  860.  
  861.         if ( (readSizeHeader = unzGetLocalExtrafield(index->zFile, headerBuff, sizeof(headerBuff) - 2)) > 0) 
  862.         {
  863.           int offset = 0;
  864.           char line[HTS_URLMAXSIZE + 2];
  865.           int lineEof = 0;
  866.           headerBuff[readSizeHeader] = '\0';
  867.           do {
  868.             char* value;
  869.             line[0] = '\0';
  870.             offset += binput(headerBuff + offset, line, sizeof(line) - 2);
  871.             if (line[0] == '\0') {
  872.               lineEof = 1;
  873.             }
  874.             value = strchr(line, ':');
  875.             if (value != NULL) {
  876.               *value++ = '\0';
  877.               if (*value == ' ' || *value == '\t') value++;
  878.               ZIP_READFIELD_INT(line, value, "X-In-Cache", dataincache);
  879.               ZIP_READFIELD_INT(line, value, "X-Statuscode", r->statuscode);
  880.               ZIP_READFIELD_STRING(line, value, "X-StatusMessage", r->msg);              // msg
  881.               ZIP_READFIELD_INT(line, value, "X-Size", r->size);           // size
  882.               ZIP_READFIELD_STRING(line, value, "Content-Type", r->contenttype);      // contenttype
  883.               ZIP_READFIELD_STRING(line, value, "X-Charset", r->charset);          // contenttype
  884.               ZIP_READFIELD_STRING(line, value, "Last-Modified", r->lastmodified);     // last-modified
  885.               ZIP_READFIELD_STRING(line, value, "Etag", r->etag);             // Etag
  886.               ZIP_READFIELD_STRING(line, value, "Location", r->location);         // 'location' pour moved
  887.               ZIP_READFIELD_STRING(line, value, "Content-Disposition", r->cdispo);           // Content-disposition
  888.               //ZIP_READFIELD_STRING(line, value, "X-Addr", ..);            // Original address
  889.               //ZIP_READFIELD_STRING(line, value, "X-Fil", ..);            // Original URI filename
  890.               ZIP_READFIELD_STRING(line, value, "X-Save", previous_save_);           // Original save filename
  891.             }
  892.           } while(offset < readSizeHeader && !lineEof);
  893.           totalHeader = offset;
  894.  
  895.                     /* Previous entry */
  896.                     if (previous_save_[0] != '\0') {
  897.                         int pathLen = (int) strlen(index->path);
  898.                         if (pathLen > 0 && strncmp(previous_save_, index->path, pathLen) == 0) {            // old (<3.40) buggy format
  899.                             strcpy(previous_save, previous_save_);
  900.                         }
  901.                         // relative ? (hack)
  902.                         else if (index->safeCache
  903.                             || (previous_save_[0] != '/'                                                                    // /home/foo/bar.gif
  904.                             && ( !isalpha(previous_save_[0]) || previous_save_[1] != ':' ) )    // c:/home/foo/bar.gif
  905.                             )
  906.                         {
  907.                             index->safeCache = 1;
  908.                             sprintf(previous_save, "%s%s", index->path, previous_save_);
  909.                         }
  910.                         // bogus format (includes buggy absolute path)
  911.                         else {
  912.                             /* guess previous path */
  913.                             if (index->fixedPath == 0) {
  914.                                 const char * start = jump_protocol_and_auth(url);
  915.                                 const char * end = start ? strchr(start, '/') : NULL;
  916.                                 int len = (int) (end - start);
  917.                                 if (start != NULL && end != NULL && len > 0 && len < 128) {
  918.                                     char piece[128 + 2];
  919.                                     const char * where;
  920.                                     piece[0] = '\0';
  921.                                     strncat(piece, start, len);
  922.                                     if ((where = strstr(previous_save_, piece)) != NULL) {
  923.                                         index->fixedPath = (int) (where - previous_save_);        // offset to relative path
  924.                                     }
  925.                                 }
  926.                             }
  927.                             if (index->fixedPath > 0) {
  928.                                 int saveLen = (int) strlen(previous_save_);
  929.                                 if (index->fixedPath < saveLen) {
  930.                                     sprintf(previous_save, "%s%s", index->path, previous_save_ + index->fixedPath);
  931.                                 } else {
  932.                                     sprintf(r->msg, "Bogus fixePath prefix for %s (prefixLen=%d)", previous_save_, (int)index->fixedPath);
  933.                                     r->statuscode = STATUSCODE_INVALID;
  934.                                 }
  935.                             } else {
  936.                                 sprintf(previous_save, "%s%s", index->path, previous_save_);
  937.                             }
  938.                         }
  939.                     }
  940.  
  941.           /* Complete fields */
  942.           r->adr=NULL;
  943.           if (r->statuscode != STATUSCODE_INVALID) {            /* Can continue */
  944.             int ok = 0;
  945.                        
  946.             // Court-circuit:
  947.             // Peut-on stocker le fichier directement sur disque?
  948.             if (ok) {
  949.               if (r->msg[0] == '\0') {
  950.                 strcpy(r->msg,"Cache Read Error : Unexpected error");
  951.               }
  952.             } else { // lire en mΘmoire
  953.               
  954.               if (!dataincache) {
  955.                                 /* Read in memory from cache */
  956.                                 if (flags & FETCH_BODY) {
  957.                                     if (strnotempty(previous_save)) {
  958.                                         FILE* fp = fopen(fconv(previous_save), "rb");
  959.                                         if (fp != NULL) {
  960.                                             r->adr = (char*) malloc(r->size + 4);
  961.                                             if (r->adr != NULL) {
  962.                                                 if (r->size > 0 && fread(r->adr, 1,  r->size, fp) != r->size) {
  963.                                                     r->statuscode=STATUSCODE_INVALID;
  964.                                                     sprintf(r->msg,"Read error in cache disk data: %s", strerror(errno));
  965.                                                 }
  966.                                             } else {
  967.                                                 r->statuscode=STATUSCODE_INVALID;
  968.                                                 strcpy(r->msg,"Read error (memory exhausted) from cache");
  969.                                             }
  970.                                             fclose(fp);
  971.                                         } else {
  972.                                             r->statuscode=STATUSCODE_INVALID;
  973.                                             sprintf(r->msg, "Read error (can't open '%s') from cache", fconv(previous_save));
  974.                                         }
  975.                                     } else {
  976.                                         r->statuscode=STATUSCODE_INVALID;
  977.                                         strcpy(r->msg,"Cached file name is invalid");
  978.                                     }
  979.                                 }
  980.               } else {
  981.                                 // lire fichier (d'un coup)
  982.                                 if (flags & FETCH_BODY) {
  983.                                     r->adr=(char*) malloc(r->size+1);
  984.                                     if (r->adr!=NULL) {
  985.                                         if (unzReadCurrentFile(index->zFile, r->adr, r->size) != r->size) {  // erreur
  986.                                             free(r->adr);
  987.                                             r->adr=NULL;
  988.                                             r->statuscode=STATUSCODE_INVALID;
  989.                                             strcpy(r->msg,"Cache Read Error : Read Data");
  990.                                         } else
  991.                                             *(r->adr+r->size)='\0';
  992.                                         //printf(">%s status %d\n",back[p].r->contenttype,back[p].r->statuscode);
  993.                                     } else {  // erreur
  994.                                         r->statuscode=STATUSCODE_INVALID;
  995.                                         strcpy(r->msg,"Cache Memory Error");
  996.                                     }
  997.                                 }
  998.                             }
  999.             }
  1000.           }    // si save==null, ne rien charger (juste en tΩte)
  1001.         } else {
  1002.           r->statuscode=STATUSCODE_INVALID;
  1003.           strcpy(r->msg,"Cache Read Error : Read Header Data");
  1004.         }
  1005.         unzCloseCurrentFile(index->zFile);
  1006.       } else {
  1007.         r->statuscode=STATUSCODE_INVALID;
  1008.         strcpy(r->msg,"Cache Read Error : Open File");
  1009.       }
  1010.  
  1011.     } else {
  1012.       r->statuscode=STATUSCODE_INVALID;
  1013.       strcpy(r->msg,"Cache Read Error : Bad Offset");
  1014.     }
  1015.   } else {
  1016.     r->statuscode=STATUSCODE_INVALID;
  1017.     strcpy(r->msg,"File Cache Entry Not Found");
  1018.   }
  1019.     if (r->location[0] != '\0') {
  1020.         r->location = strdup(r->location);
  1021.     } else {
  1022.         r->location = NULL;
  1023.     }
  1024.   return r;
  1025. }
  1026.  
  1027.  
  1028. /* ------------------------------------------------------------ */
  1029. /* Old HTTrack cache (dat/ndx) format                           */
  1030. /* ------------------------------------------------------------ */
  1031.  
  1032. static int cache_brstr(char* adr,char* s) {
  1033.   int i;
  1034.   int off;
  1035.   char buff[256 + 1];
  1036.   off=binput(adr,buff,256);
  1037.   adr+=off;
  1038.   sscanf(buff,"%d",&i);
  1039.   if (i>0)
  1040.     strncpy(s,adr,i);
  1041.   *(s+i)='\0';
  1042.   off+=i;
  1043.   return off;
  1044. }
  1045.  
  1046. static void cache_rstr(FILE* fp,char* s) {
  1047.   INTsys i;
  1048.   char buff[256+4];
  1049.   linput(fp,buff,256);
  1050.   sscanf(buff,INTsysP,&i);
  1051.   if (i < 0 || i > 32768)    /* error, something nasty happened */
  1052.     i=0;
  1053.   if (i>0) {
  1054.     if ((int) fread(s,1,i,fp) != i) {
  1055.       int fread_cache_failed = 0;
  1056.       assertf(fread_cache_failed);
  1057.     }
  1058.   }
  1059.   *(s+i)='\0';
  1060. }
  1061.  
  1062. static char* cache_rstr_addr(FILE* fp) {
  1063.   INTsys i;
  1064.   char* addr = NULL;
  1065.   char buff[256+4];
  1066.   linput(fp,buff,256);
  1067.   sscanf(buff,"%d",&i);
  1068.   if (i < 0 || i > 32768)    /* error, something nasty happened */
  1069.     i=0;
  1070.   if (i > 0) {
  1071.     addr = malloc(i + 1);
  1072.     if (addr != NULL) {
  1073.       if ((int) fread(addr,1,i,fp) != i) {
  1074.         int fread_cache_failed = 0;
  1075.         assertf(fread_cache_failed);
  1076.       }
  1077.       *(addr+i)='\0';
  1078.     }
  1079.   }
  1080.   return addr;
  1081. }
  1082.  
  1083. static void cache_rint(FILE* fp,int* i) {
  1084.   char s[256];
  1085.   cache_rstr(fp,s);
  1086.   sscanf(s,"%d",i);
  1087. }
  1088.  
  1089. static void cache_rLLint(FILE* fp,unsigned long* i) {
  1090.     int l;
  1091.   char s[256];
  1092.   cache_rstr(fp,s);
  1093.   sscanf(s,"%d",&l);
  1094.     *i = (unsigned long)l;
  1095. }
  1096.  
  1097. static int PT_LoadCache__Old(PT_Index index_, const char *filename) {
  1098.     if (index_ != NULL && filename != NULL) {
  1099.         char * pos = strrchr(filename, '.');
  1100.         PT_Index__Old cache = &index_->slots.formatOld;
  1101.         long int ndxSize;
  1102.         cache->filenameDat[0] = '\0';
  1103.         cache->filenameNdx[0] = '\0';
  1104.         cache->path[0] = '\0';
  1105.  
  1106.         {
  1107.             PT_Index__Old index = cache;
  1108.             const char * abpath;
  1109.             int slashes;
  1110.             /* -------------------- COPY OF THE __New() CODE -------------------- */
  1111.             /* Compute base path for this index - the filename MUST be absolute! */
  1112.             for(slashes = 2, abpath = filename + (int)strlen(filename) - 1 
  1113.                 ; abpath > filename && ( ( *abpath != '/'&& *abpath != '\\' ) || --slashes > 0)
  1114.                 ; abpath--);
  1115.             index->path[0] = '\0';
  1116.             if (slashes == 0 && *abpath != 0) {
  1117.                 int i;
  1118.                 strncat(index->path, filename, (int) ( abpath - filename ) + 1 );
  1119.                 for(i = 0 ; index->path[i] != 0 ; i++) {
  1120.                     if (index->path[i] == '\\') {
  1121.                         index->path[i] = '/';
  1122.                     }
  1123.                 }
  1124.             }
  1125.             /* -------------------- END OF COPY OF THE __New() CODE -------------------- */
  1126.         }
  1127.  
  1128.         /* Index/data filenames */
  1129.         if (pos != NULL) {
  1130.             int nLen = (int) (pos - filename);
  1131.             strncat(cache->filenameDat, filename, nLen);
  1132.             strncat(cache->filenameNdx, filename, nLen);
  1133.             strcat(cache->filenameDat, ".dat");
  1134.             strcat(cache->filenameNdx, ".ndx");
  1135.         }
  1136.         ndxSize = filesize(cache->filenameNdx);
  1137.         cache->timestamp = file_timestamp(cache->filenameDat);
  1138.         cache->dat = fopen(cache->filenameDat, "rb");
  1139.         cache->ndx = fopen(cache->filenameNdx, "rb");
  1140.         if (cache->dat != NULL && cache->ndx != NULL && ndxSize > 0) {
  1141.             char * use = malloc(ndxSize + 1);
  1142.             if (fread(use, 1, ndxSize, cache->ndx) == ndxSize) {
  1143.                 char firstline[256];
  1144.                 char* a=use;
  1145.                 use[ndxSize] = '\0';
  1146.                 a += cache_brstr(a, firstline);
  1147.                 if (strncmp(firstline,"CACHE-",6)==0) {       // Nouvelle version du cache
  1148.                     if (strncmp(firstline,"CACHE-1.",8)==0) {      // Version 1.1x
  1149.                         cache->version=(int)(firstline[8]-'0');           // cache 1.x
  1150.                         if (cache->version <= 5) {
  1151.                             a+=cache_brstr(a,firstline);
  1152.                             strcpy(cache->lastmodified,firstline);
  1153.                         } else {
  1154.                             // fprintf(opt->errlog,"Cache: version 1.%d not supported, ignoring current cache"LF,cache->version);
  1155.                             fclose(cache->dat);
  1156.                             cache->dat=NULL;
  1157.                             free(use);
  1158.                             use=NULL;
  1159.                         }
  1160.                     } else {        // non supportΘ
  1161.                         // fspc(opt->errlog,"error"); fprintf(opt->errlog,"Cache: %s not supported, ignoring current cache"LF,firstline);
  1162.                         fclose(cache->dat);
  1163.                         cache->dat=NULL;
  1164.                         free(use);
  1165.                         use=NULL;
  1166.                     }
  1167.                     /* */
  1168.                 } else {              // Vieille version du cache
  1169.                     /* */
  1170.                     // fspc(opt->log,"warning"); fprintf(opt->log,"Cache: importing old cache format"LF);
  1171.                     cache->version=0;        // cache 1.0
  1172.                     strcpy(cache->lastmodified,firstline); 
  1173.                 }
  1174.  
  1175.                 /* Create hash table for the cache (MUCH FASTER!) */
  1176.                 if (use) {
  1177.                     char line[HTS_URLMAXSIZE*2];
  1178.                     char linepos[256];
  1179.                     int  pos;
  1180.                     int firstSeen = 0;
  1181.                     while ( (a!=NULL) && (a < (use + ndxSize) ) ) {
  1182.                         a=strchr(a+1,'\n');     /* start of line */
  1183.                         if (a) {
  1184.                             a++;
  1185.                             /* read "host/file" */
  1186.                             a+=binput(a,line,HTS_URLMAXSIZE);
  1187.                             a+=binput(a,line+strlen(line),HTS_URLMAXSIZE);
  1188.                             /* read position */
  1189.                             a+=binput(a,linepos,200);
  1190.                             sscanf(linepos,"%d",&pos);
  1191.  
  1192.                             /* Add entry */
  1193.                             inthash_add(cache->hash,line,pos);
  1194.  
  1195.                             /* First link as starting URL */
  1196.                             if (!firstSeen) {
  1197.                                 if (strstr(line, "/robots.txt") == NULL) {
  1198.                                     PT_Index__Old index = cache;
  1199.                                     firstSeen = 1;
  1200.                                     if (!link_has_authority(line))
  1201.                                         strcat(index->startUrl, "http://");
  1202.                                     strcat(index->startUrl, line);
  1203.                                 }
  1204.                             }
  1205.  
  1206.                         }
  1207.                     }
  1208.                     /* Not needed anymore! */
  1209.                     free(use);
  1210.                     use=NULL;
  1211.                     return 1;
  1212.                 }
  1213.             }
  1214.         }
  1215.     }
  1216.     return 0;
  1217. }
  1218.  
  1219. static String DecodeUrl(const char * url) {
  1220.     int i;
  1221.     String s = STRING_EMPTY;
  1222.     StringClear(s);
  1223.     for(i = 0 ; url[i] != '\0' ; i++) {
  1224.         if (url[i] == '+') {
  1225.             StringAddchar(s, ' ');
  1226.         } else if (url[i] == '%') {
  1227.             if (url[i + 1] == '%') {
  1228.                 StringAddchar(s, '%');
  1229.                 i++;
  1230.             } else if (url[i + 1] != 0 && url[i + 2] != 0) {
  1231.                 char tmp[3];
  1232.                 int codepoint = 0;
  1233.                 tmp[0] = url[i + 1];
  1234.                 tmp[1] = url[i + 2];
  1235.                 tmp[2] = 0;
  1236.                 if (sscanf(tmp, "%x", &codepoint) == 1) {
  1237.                     StringAddchar(s, (char)codepoint);
  1238.                 }
  1239.                 i += 2;
  1240.             }
  1241.         } else {
  1242.             StringAddchar(s, url[i]);
  1243.         }
  1244.     }
  1245.     return s;
  1246. }
  1247.  
  1248. static PT_Element PT_ReadCache__Old(PT_Index index, const char* url, int flags) {
  1249.     PT_Element retCode;
  1250.     MutexLock(&index->slots.formatOld.fileLock);
  1251.     {
  1252.         retCode = PT_ReadCache__Old_u(index, url, flags);
  1253.     }
  1254.     MutexUnlock(&index->slots.formatOld.fileLock);
  1255.     return retCode;
  1256. }
  1257.  
  1258. static PT_Element PT_ReadCache__Old_u(PT_Index index_, const char* url, int flags) {
  1259.     PT_Index__Old cache = (PT_Index__Old) &index_->slots.formatOld;
  1260.   long int hash_pos;
  1261.   int hash_pos_return;
  1262.   char location_default[HTS_URLMAXSIZE*2];
  1263.   char previous_save[HTS_URLMAXSIZE*2];
  1264.   char previous_save_[HTS_URLMAXSIZE*2];
  1265.   PT_Element r;
  1266.   int ok=0;
  1267.  
  1268.     if (cache == NULL || cache->hash == NULL || url == NULL || *url == 0)
  1269.         return NULL;
  1270.     if ((r = PT_ElementNew()) == NULL)
  1271.         return NULL;
  1272.     location_default[0] = '\0';
  1273.     previous_save[0] = previous_save_[0] = '\0';
  1274.   memset(r, 0, sizeof(_PT_Element));
  1275.   r->location = location_default;
  1276.     strcpy(r->location, ""); 
  1277.     if (strncmp(url, "http://", 7) == 0)
  1278.         url += 7;
  1279.   hash_pos_return=inthash_read(cache->hash, url, (long int*)&hash_pos);
  1280.  
  1281.   if (hash_pos_return) {
  1282.     int pos = (int) hash_pos;     /* simply */
  1283.  
  1284.     if (fseek(cache->dat, (pos>0) ? pos : (-pos), SEEK_SET) == 0) {
  1285.             /* Importer cache1.0 */
  1286.             if (cache->version==0) {
  1287.                 OLD_htsblk old_r;
  1288.                 if (fread((char*) &old_r,1,sizeof(old_r),cache->dat) == sizeof(old_r)) { // lire tout (y compris statuscode etc)
  1289.                     int i;
  1290.                     String urlDecoded;
  1291.                     r->statuscode = old_r.statuscode;
  1292.                     r->size = old_r.size;        // taille fichier
  1293.                     strcpy(r->msg, old_r.msg);
  1294.                     strcpy(r->contenttype, old_r.contenttype);
  1295.  
  1296.                     /* Guess the destination filename.. this sucks, because this method is not reliable.
  1297.                         Yes, the old 1.0 cache format was *that* bogus. /rx */
  1298. #define FORBIDDEN_CHAR(c) (c == '~' \
  1299.     || c == '\\' \
  1300.     || c == ':' \
  1301.     || c == '*' \
  1302.     || c == '?' \
  1303.     || c == '\"' \
  1304.     || c == '<' \
  1305.     || c == '>' \
  1306.     || c == '|' \
  1307.     || c == '@' \
  1308.     || ((unsigned char) c ) <= 31 \
  1309.     || ((unsigned char) c ) == 127 \
  1310.     )
  1311.                     urlDecoded = DecodeUrl(jump_protocol_and_auth(url));
  1312.                     strcpy(previous_save_, StringBuff(urlDecoded));
  1313.                     StringFree(urlDecoded);
  1314.                     for(i = 0 ; previous_save_[i] != '\0' && previous_save_[i] != '?' ; i++) {
  1315.                         if (FORBIDDEN_CHAR(previous_save_[i])) {
  1316.                             previous_save_[i] = '_';
  1317.                         }
  1318.                     }
  1319.                     previous_save_[i] = '\0';
  1320. #undef FORBIDDEN_CHAR
  1321.                 ok = 1;     /* import  ok */
  1322.             }
  1323.       /* */
  1324.       /* Cache 1.1 */
  1325.       } else {
  1326.         char check[256];
  1327.         unsigned long size_read;
  1328.         check[0]='\0';
  1329.         //
  1330.         cache_rint(cache->dat,&r->statuscode);
  1331.         cache_rLLint(cache->dat,&r->size);
  1332.         cache_rstr(cache->dat,r->msg);
  1333.         cache_rstr(cache->dat,r->contenttype);
  1334.         if (cache->version >= 3)
  1335.           cache_rstr(cache->dat,r->charset);
  1336.         cache_rstr(cache->dat,r->lastmodified);
  1337.         cache_rstr(cache->dat,r->etag);
  1338.         cache_rstr(cache->dat,r->location);
  1339.         if (cache->version >= 2)
  1340.           cache_rstr(cache->dat,r->cdispo);
  1341.         if (cache->version >= 4) {
  1342.           cache_rstr(cache->dat, previous_save_);  // adr
  1343.           cache_rstr(cache->dat, previous_save_);  // fil
  1344.           previous_save[0] = '\0';
  1345.           cache_rstr(cache->dat, previous_save_);  // save
  1346.         }
  1347.         if (cache->version >= 5) {
  1348.           r->headers = cache_rstr_addr(cache->dat);
  1349.         }
  1350.         //
  1351.         cache_rstr(cache->dat,check);
  1352.         if (strcmp(check,"HTS")==0) {           /* intΘgritΘ OK */
  1353.           ok=1;
  1354.         }
  1355.         cache_rLLint(cache->dat, &size_read);       /* lire size pour Ωtre s√r de la taille dΘclarΘe (rΘΘcrire) */
  1356.         if (size_read > 0) {                         /* si inscrite ici */
  1357.           r->size = size_read;
  1358.         } else {                              /* pas de donnΘes directement dans le cache, fichier prΘsent? */
  1359.                     r->size = 0;
  1360.         }
  1361.       }
  1362.  
  1363.             /* Check destination filename */
  1364.  
  1365.             {
  1366.                 PT_Index__Old index = cache;
  1367.                 /* -------------------- COPY OF THE __New() CODE -------------------- */
  1368.                 if (previous_save_[0] != '\0') {
  1369.                     int pathLen = (int) strlen(index->path);
  1370.                     if (pathLen > 0 && strncmp(previous_save_, index->path, pathLen) == 0) {            // old (<3.40) buggy format
  1371.                         strcpy(previous_save, previous_save_);
  1372.                     }
  1373.                     // relative ? (hack)
  1374.                     else if (index->safeCache
  1375.                         || (previous_save_[0] != '/'                                                                    // /home/foo/bar.gif
  1376.                         && ( !isalpha(previous_save_[0]) || previous_save_[1] != ':' ) )    // c:/home/foo/bar.gif
  1377.                         )
  1378.                     {
  1379.                         index->safeCache = 1;
  1380.                         sprintf(previous_save, "%s%s", index->path, previous_save_);
  1381.                     }
  1382.                     // bogus format (includes buggy absolute path)
  1383.                     else {
  1384.                         /* guess previous path */
  1385.                         if (index->fixedPath == 0) {
  1386.                             const char * start = jump_protocol_and_auth(url);
  1387.                             const char * end = start ? strchr(start, '/') : NULL;
  1388.                             int len = (int) (end - start);
  1389.                             if (start != NULL && end != NULL && len > 0 && len < 128) {
  1390.                                 char piece[128 + 2];
  1391.                                 const char * where;
  1392.                                 piece[0] = '\0';
  1393.                                 strncat(piece, start, len);
  1394.                                 if ((where = strstr(previous_save_, piece)) != NULL) {
  1395.                                     index->fixedPath = (int) (where - previous_save_);        // offset to relative path
  1396.                                 }
  1397.                             }
  1398.                         }
  1399.                         if (index->fixedPath > 0) {
  1400.                             int saveLen = (int) strlen(previous_save_);
  1401.                             if (index->fixedPath < saveLen) {
  1402.                                 sprintf(previous_save, "%s%s", index->path, previous_save_ + index->fixedPath);
  1403.                             } else {
  1404.                                 sprintf(r->msg, "Bogus fixePath prefix for %s (prefixLen=%d)", previous_save_, (int)index->fixedPath);
  1405.                                 r->statuscode = STATUSCODE_INVALID;
  1406.                             }
  1407.                         } else {
  1408.                             sprintf(previous_save, "%s%s", index->path, previous_save_);
  1409.                         }
  1410.                     }
  1411.                 }
  1412.                 /* -------------------- END OF COPY OF THE __New() CODE -------------------- */
  1413.             }
  1414.  
  1415.       /* Read data */
  1416.             if (ok) {
  1417.                 r->adr = NULL;
  1418.                 if ( (r->statuscode>=0) && (r->statuscode<=999)) {
  1419.                     r->adr = NULL;
  1420.                     if (pos<0) {
  1421.                         if (flags & FETCH_BODY) {
  1422.                             FILE* fp = fopen(previous_save, "rb");
  1423.                             if (fp != NULL) {
  1424.                                 r->adr = (char*) malloc(r->size + 1);
  1425.                                 if (r->adr != NULL) {
  1426.                                     if (r->size > 0 && fread(r->adr, 1, r->size, fp) != r->size) {
  1427.                                         r->statuscode=STATUSCODE_INVALID;
  1428.                                         strcpy(r->msg,"Read error in cache disk data");
  1429.                                     }
  1430.                                     r->adr[r->size] = '\0';
  1431.                                 } else {
  1432.                                     r->statuscode=STATUSCODE_INVALID;
  1433.                                     strcpy(r->msg,"Read error (memory exhausted) from cache");
  1434.                                 }
  1435.                                 fclose(fp);
  1436.                             } else {
  1437.                                 r->statuscode = STATUSCODE_INVALID;
  1438.                                 strcpy(r->msg, "Previous cache file not found (2)");
  1439.                             }
  1440.                         }
  1441.                     } else {
  1442.                         // lire fichier (d'un coup)
  1443.                         if (flags & FETCH_BODY) {
  1444.                             r->adr=(char*) malloc(r->size + 1);
  1445.                             if (r->adr!=NULL) {
  1446.                                 if (fread(r->adr, 1, r->size,cache->dat) != r->size) {  // erreur
  1447.                                     free(r->adr);
  1448.                                     r->adr=NULL;
  1449.                                     r->statuscode=STATUSCODE_INVALID;
  1450.                                     strcpy(r->msg,"Cache Read Error : Read Data");
  1451.                                 } else
  1452.                                     r->adr[r->size] = '\0';
  1453.                             } else {  // erreur
  1454.                                 r->statuscode=STATUSCODE_INVALID;
  1455.                                 strcpy(r->msg,"Cache Memory Error");
  1456.                             }
  1457.                         }
  1458.                     }
  1459.                 } else {
  1460.           r->statuscode=STATUSCODE_INVALID;
  1461.           strcpy(r->msg,"Cache Read Error : Bad Data");
  1462.         }
  1463.       } else {  // erreur
  1464.         r->statuscode=STATUSCODE_INVALID;
  1465.         strcpy(r->msg,"Cache Read Error : Read Header");
  1466.       }
  1467.     } else {
  1468.       r->statuscode=STATUSCODE_INVALID;
  1469.       strcpy(r->msg,"Cache Read Error : Seek Failed");
  1470.     }
  1471.   } else {
  1472.     r->statuscode=STATUSCODE_INVALID;
  1473.     strcpy(r->msg,"File Cache Entry Not Found");
  1474.   }
  1475.     if (r->location[0] != '\0') {
  1476.         r->location = strdup(r->location);
  1477.     } else {
  1478.         r->location = NULL;
  1479.     }
  1480.   return r;
  1481. }
  1482.  
  1483. static int PT_LookupCache__Old(PT_Index index, const char* url) {
  1484.     int retCode;
  1485.     MutexLock(&index->slots.formatOld.fileLock);
  1486.     {
  1487.         retCode = PT_LookupCache__Old_u(index, url);
  1488.     }
  1489.     MutexUnlock(&index->slots.formatOld.fileLock);
  1490.     return retCode;
  1491. }
  1492.  
  1493. static int PT_LookupCache__Old_u(PT_Index index_, const char* url) {
  1494.     if (index_ != NULL) {
  1495.         PT_Index__New cache = (PT_Index__New) &index_->slots.formatNew;
  1496.         if (cache == NULL || cache->hash == NULL || url == NULL || *url == 0)
  1497.             return 0;
  1498.         if (strncmp(url, "http://", 7) == 0)
  1499.             url += 7;
  1500.         if (inthash_read(cache->hash, url, NULL))
  1501.             return 1;
  1502.     }
  1503.     return 0;
  1504. }
  1505.  
  1506.